The present invention relates generally to coding algorithms for a digital communications system and, more particularly, to a reduced search symbol estimation algorithm for decoding convolutional codes.
The basic function of a communication system is to send information over a communication channel from a source that generates the information to one or more destinations. In a digital communication system, the information is converted into a digital format and then transmitted over the communication channel. The transmission of digital information is subject to the adverse effects of the communication channel, such as co-channel and adjacent channel interference, noise, dispersion, and fading. These effects introduce errors called xe2x80x9cchannel errorsxe2x80x9d into the transmitted data stream. These effects are particularly severe in a radio communication system.
In 1948, Claude E. Shannon demonstrated in a landmark paper that by proper encoding of the digital information prior to transmission, the errors introduced by a noisy channel can be reduced to any desired level without sacrificing the rate of information transmission. Encoding is the process of adding redundancy to information prior to its transmission so that errors which may occur during transmission can be detected and/or corrected. At the receiving end, the decoder makes use of the redundant information and a priori knowledge of the coding scheme to detect and/or correct errors that may have occurred during transmission of the information.
One class of error correcting codes commonly used in digital communication systems are convolutional codes. In convolutional codes, an information sequence is fed into the encoder k bits at a time. For each k bits input to the encoder, n bits (n greater than k) are output. The n output bits form a codeword selected from a set of codewords C. Thus, a convolutional code represents a mapping of the k input bits into an n bit codeword selected from a codeword set C.
One fundamental characteristic of a convolutional code is that each codeword output by the encoder is determined not only by the k input bits, but also by the information bits input during a previous coding interval. This dependence on the previous information bits causes the encoder to act like a finite state machine. One method commonly used to represent a convolutional code is with a trellis diagram. An exemplary trellis diagram for a rate xc2xd convolutional code is shown in FIG. 1. In the code shown in FIG. 1, one bit is input to the encoder during each coding interval and two bits are output. The coded output can thus take one of four possible values. Each trellis node corresponds to one of the four possible values and is often returned to as a node or state. Each column of nodes in the trellis diagram represents an instant of time called a coding interval or stage. The set of nodes repeats for each coding interval. Transitions between states are represented in the trellis diagram as branches connecting nodes in adjacent coding intervals. Each branch is associated with a particular symbol or codeword that could have been transmitted. A series of connected branches defines a path through the trellis. Each path represents a valid received symbol sequence.
Encoding proceeds from left to right through the trellis diagram. At each coding interval, k bits are input to the encoder, which generates a coded output containing n bits. Each path through the trellis diagram extending from the starting state to the ending state corresponds to a valid symbol sequence. It is important to note that there is a one-to-one correspondence between valid symbol sequences and paths through the trellis. The function of the decoder is to determine the symbol sequence transmitted based on the received sequence.
Numerous techniques have been devised for decoding convolutional codes. The fundamental task implemented by each of these various approaches is essentially the same; to find a path through the trellis that is xe2x80x9cclosestxe2x80x9d to the received sequence. The closest path corresponds to the code sequence which has the highest probability of being transmitted given the received sequence.
The method for decoding a received symbol sequence that is considered optimum is called maximum likelihood sequence estimation (MLSE). In MLSE, the decoder tries to find the path through the trellis that best matches a received symbol sequence. Each branch of the trellis is assigned a metric that represents the likelihood of the symbol corresponding to that branch being part of the transmitted symbol sequence. A path metric is then computed for a path by summing the branch metrics associated with each branch in that path. The path that most closely matches the received symbol sequence is the one with the lowest accumulated path metric. The symbol sequence corresponding to the path with the lowest path metric is output as the decoded sequence.
In most codes, the number of possible paths through the trellis is quite large and it is therefore not possible to compute a path metric for every possible path through the trellis. Therefore, great effort has been expended in finding new algorithms that simplify the task of finding the closest path to the received symbol sequence. One such algorithm is called the Viterbi algorithm.
In the Viterbi algorithm, the path with the lowest path metric is found by sequentially moving through the trellis from beginning to end and, at each stage, retaining one xe2x80x9csurvivor pathxe2x80x9d for each state or node.- The survivor path is defined as the path leading up to a particular node that has the lowest accumulated path metric. For any given interval, there will be M survivors where M is the number of possible states or nodes. Once the survivor path is determined for each state, the survivor paths are extended to the next interval and the survivors for the next stage are determined. Recursion can proceed indefinitely without the number of surviving paths exceeding M. When the final stage is reached, the decoder determines which of the final survivor paths is optimum and outputs the corresponding bits.
Even though the Viterbi algorithm greatly simplifies the task of finding the closest path, the complexity of the Viterbi algorithm grows exponentially as the memory of the encoder increases. Consequently, the Viterbi algorithm is not used for codes with a long constraint length. Another drawback is that the Viterbi algorithm generates a hard decision.
Another commonly used algorithm is called the M-algorithm (MA). In the MA, for each coding interval in the trellis, the number of surviving paths retained by the decoder is restricted to a fixed number N less the number of possible states. At each stage, the MA chooses the N best paths based on the accumulated path metrics. Thus, the MA restricts the search through the trellis to a fixed number of states at any given time interval. If the selected value for N is too small, there will be a high probability of deleting the path corresponding to the transmitted symbol sequence and hence a high error probability.
Symbol estimation algorithms provide an alternative to sequence estimation algorithms. While typically more complex than sequence estimation algorithms, and not as well understood, this class of algorithms has some advantages. One advantage is that symbol estimation algorithms produce symbol reliability values (soft values) as part of their normal design. In contrast, the Viterbi algorithm needs to be modified in order to produce reliability values. Moreover, the soft values produced by a modified Viterbi algorithm are not as accurate as those produced by symbol estimation algorithms.
Although in this patent application we focus on applications of our invention to decoders for convolutional codes, it is obvious to one skilled in the art that our invention can also be used for estimation of digital symbols in the presence of inter-symbol interference (i.e., for MAP equalization).
The present invention is a reduced search symbol estimation algorithm that approximates a MAP decoder. The reduced search symbol estimation algorithm includes a forward recursion, a backward recursion, and a combining step. For each stage k, the decoder performs a forward recursion up to stage k-1 and a backward recursion up to stage k. To reduce complexity, the decoder does not retain all stages during the forward and backward recursions. Instead, at each stage of the forward and backward recursions, the number of surviving states is limited to a predetermined number of states which is less than the total number of possible states. Surviving states in the forward recursion are denoted Qk. Surviving states in the backward recursion are denoted Rk. At each stage of the recursion, the decoder extends branches one stage forward (or backward) from the survivors at the previous stage. The states at which the extended branches end become candidate states. The decoder compares the accumulated path metrics for the branches BK for each candidate state and retains a predetermined number of states that is less than the total number of states.
During the combining step, a log-likelihood ratio or soft value is computed for the current stage k by combining the forward state metrics for the survivors in Qkxe2x88x921, the backward state metrics for the survivors in Rk, and the branch metrics connecting survivors in both sets. To calculate the likelihood ratio, the set of connecting branches Bk is partitioned into two subsets, Bk0 and Bk1, corresponding respectively to either 0 or 1 for the current bit. The log likelihood ratio is then given by the following equation:       L    k    =                    max                  B          k0                    ⁢              *                  (                                                    α                                  k                  -                  1                                            ⁡                              (                                  s                  xe2x80x2                                )                                      =                                                            c                  k                                ⁡                                  (                                                            s                      xe2x80x2                                        ,                    s                                    )                                            +                                                β                  k                                ⁡                                  (                  s                  )                                                              )                      -                  max                  B          k1                    ⁢              *                  (                                                    α                                  k                  -                  1                                            ⁡                              (                                  s                  xe2x80x2                                )                                      +                                          c                k                            ⁡                              (                                                      s                    xe2x80x2                                    ,                  s                                )                                      +                                          β                k                            ⁡                              (                s                )                                              )                    
To prevent the set Bk from being empty, the decoder can perform an augmenting step during the forward and backward recursions. For example, assume that the augmenting step is performed during the backward recursion. The decoder would perform a complete forward recursion, storing the state metrics for the survivors at each stage. During the backward recursion, the decoder would determine the survivor states at each stage based on the accumulated path metrics. The decoder would then determine whether the survivors at stage k in the backward recursion include a survivor from the forward recursion at the same stage. If not, the decoder would select a survivor state from the same stage of the forward recursion to include as a survivor in the backward recursion. This procedure can also be used to ensure that neither subset of Bk is empty.
In another embodiment of the invention, an augmenting step is performed after the forward and backward recursions but prior to the computation of the likelihood ratio. That is, prior to computing the likelihood ratio, the decoder determines whether any connecting branches exist connecting survivors in QKxe2x88x921 to backward survivors in RK. If not, an alternate survivor is selected for inclusion in either QKxe2x88x921 or RK to enable calculation of the likelihood ratio. The alternate state could be selected by extending branches forward (or backward) one stage from one of the survivors and selecting the best extended path. Another method would be to trace back along a survivor path from one of the current survivors to find a path that had been previously deleted. For example, the decoder could trace back from the survivors in Rk to find deleted branches that connect to members in Qk. The shortest regenerated path would then be included in Rk.